const { categories, Category } = require('../models/Category');
const { generateId } = require('../utils');
const { validateNumber, validateRequiredFields } = require('../utils');
const { dbConfig } = require('../config/database');

// 获取所有分类
const getAllCategories = async (req, res) => {
  try {
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const dbCategories = await Category.find({});
        res.status(200).json(dbCategories);
      } catch (dbError) {
        console.error('数据库查询失败:', dbError);
        // 降级到内存数据
        res.status(200).json(categories);
      }
    } else {
      // 使用内存数据模式
      res.status(200).json(categories);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '获取分类列表失败',
      message: error.message 
    });
  }
};

// 根据ID获取分类
const getCategoryById = async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '分类ID必须是数字' 
      });
    }
    
    const categoryId = parseInt(id);
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const category = await Category.findById(categoryId);
        if (!category) {
          return res.status(404).json({ 
            error: '分类未找到',
            message: `ID为${categoryId}的分类不存在`
          });
        }
        res.status(200).json(category);
      } catch (dbError) {
        console.error('数据库查询失败:', dbError);
        // 降级到内存数据
        const category = categories.find(c => c.id === categoryId);
        if (!category) {
          return res.status(404).json({ 
            error: '分类未找到',
            message: `ID为${categoryId}的分类不存在`
          });
        }
        res.status(200).json(category);
      }
    } else {
      // 使用内存数据模式
      const category = categories.find(c => c.id === categoryId);
      if (!category) {
        return res.status(404).json({ 
          error: '分类未找到',
          message: `ID为${categoryId}的分类不存在`
        });
      }
      res.status(200).json(category);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '获取分类信息失败',
      message: error.message 
    });
  }
};

// 创建新分类
const createCategory = async (req, res) => {
  try {
    const { name, description } = req.body;
    
    // 验证必填字段
    const validation = validateRequiredFields({ name }, ['name']);
    if (!validation.isValid) {
      return res.status(400).json({ 
        error: '字段验证失败', 
        message: validation.errors.join(', ') 
      });
    }
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const existingCategory = await Category.findOne({ name });
        if (existingCategory) {
          return res.status(400).json({ 
            error: '分类已存在', 
            message: '该分类名称已存在' 
          });
        }
        
        const newCategory = new Category({ name, description: description || '' });
        const savedCategory = await newCategory.save();
        res.status(201).json(savedCategory);
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const existingCategory = categories.find(c => c.name === name);
        if (existingCategory) {
          return res.status(400).json({ 
            error: '分类已存在', 
            message: '该分类名称已存在' 
          });
        }
        
        const newCategory = new Category(generateId(categories), name, description || '');
        categories.push(newCategory);
        res.status(201).json(newCategory);
      }
    } else {
      // 使用内存数据模式
      const existingCategory = categories.find(c => c.name === name);
      if (existingCategory) {
        return res.status(400).json({ 
          error: '分类已存在', 
          message: '该分类名称已存在' 
        });
      }
      
      const newCategory = new Category(generateId(categories), name, description || '');
      categories.push(newCategory);
      res.status(201).json(newCategory);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '创建分类失败',
      message: error.message 
    });
  }
};

// 更新分类
const updateCategory = async (req, res) => {
  try {
    const { id } = req.params;
    const { name, description } = req.body;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '分类ID必须是数字' 
      });
    }
    
    const categoryId = parseInt(id);
    
    // 验证必填字段
    const validation = validateRequiredFields({ name }, ['name']);
    if (!validation.isValid) {
      return res.status(400).json({ 
        error: '字段验证失败', 
        message: validation.errors.join(', ') 
      });
    }
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const category = await Category.findByIdAndUpdate(
          categoryId,
          { name, description: description || '' },
          { new: true, runValidators: true }
        );
        
        if (!category) {
          return res.status(404).json({ 
            error: '分类未找到',
            message: `ID为${categoryId}的分类不存在`
          });
        }
        
        res.status(200).json(category);
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const categoryIndex = categories.findIndex(c => c.id === categoryId);
        if (categoryIndex === -1) {
          return res.status(404).json({ 
            error: '分类未找到',
            message: `ID为${categoryId}的分类不存在`
          });
        }
        
        categories[categoryIndex].update(name, description || '');
        res.status(200).json(categories[categoryIndex]);
      }
    } else {
      // 使用内存数据模式
      const categoryIndex = categories.findIndex(c => c.id === categoryId);
      if (categoryIndex === -1) {
        return res.status(404).json({ 
          error: '分类未找到',
          message: `ID为${categoryId}的分类不存在`
        });
      }
      
      categories[categoryIndex].update(name, description || '');
      res.status(200).json(categories[categoryIndex]);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '更新分类失败',
      message: error.message 
    });
  }
};

// 删除分类
const deleteCategory = async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '分类ID必须是数字' 
      });
    }
    
    const categoryId = parseInt(id);
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const category = await Category.findByIdAndDelete(categoryId);
        if (!category) {
          return res.status(404).json({ 
            error: '分类未找到',
            message: `ID为${categoryId}的分类不存在`
          });
        }
        
        res.status(200).json({ message: '分类删除成功' });
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const categoryIndex = categories.findIndex(c => c.id === categoryId);
        if (categoryIndex === -1) {
          return res.status(404).json({ 
            error: '分类未找到',
            message: `ID为${categoryId}的分类不存在`
          });
        }
        
        categories.splice(categoryIndex, 1);
        res.status(200).json({ message: '分类删除成功' });
      }
    } else {
      // 使用内存数据模式
      const categoryIndex = categories.findIndex(c => c.id === categoryId);
      if (categoryIndex === -1) {
        return res.status(404).json({ 
          error: '分类未找到',
          message: `ID为${categoryId}的分类不存在`
        });
      }
      
      categories.splice(categoryIndex, 1);
      res.status(200).json({ message: '分类删除成功' });
    }
  } catch (error) {
    res.status(500).json({ 
      error: '删除分类失败',
      message: error.message 
    });
  }
};

module.exports = {
  getAllCategories,
  getCategoryById,
  createCategory,
  updateCategory,
  deleteCategory
};